In recent years, the xDSL communication system including the ADSL (Asymmetric Digital Subscriber Line) communication system, the HDSL (High-bit-rate Digital Subscriber Line) communication system and the SDSL communication system for performing a high-speed digital communication of several mega bits per second using the existing telephone copper cable have been closely watched. The xDSL communication system is called the DMT (Discrete Multi-Tone) modem system. This system is standardized in T1.413, etc. of ANSI.
This digital communication system, especially in the case where the xDSL transmission path and the ISDN transmission path of the half-duplex ISDN communication system are bound together as an aggregated line or otherwise placed adjacently to each other, poses the problem that the xDSL communication through the xDSL transmission path is affected by interference noises from the ISDN transmission path or other lines and decreases in speed. For solving this problem, various techniques are used.
FIG. 12 shows the interference noises of an ISDN transmission path 2 from a central office (CO) 1, which affect an ADSL transmission path 3 constituting a xDSL transmission path bound with the ISDN transmission path 2 midway as an aggregated line.
When viewed from the ADSL terminal equipment (ATU-R; ADSL transceiver unit, remote terminal end) 4 constituting a communication unit at a terminal of the ADSL communication system, the interference noise transmitted through the ADSL transmission path 3 by the office equipment (ISDN LT) 7 of the ISDN transmission system is called the FEXT (Far-End crossTalk) noise, while the interference noise transmitted through the ADSL transmission path 3 by the terminal equipment (ISDN NT1) 6 of the ISDN transmission system is called the NEXT (Near-End crossTalk) noise. Especially, these noises are transmitted to the ADSL terminal equipment (ATU-R) 4 through the ADSL transmission path 3 which is coupled with the ISDN transmission path 2 midway as an aggregated line.
When viewed from the ADSL office equipment (ATU-C: ADSL transceiver unit, central office end) 5 constituting the office equipment of the ADSL communication system, on the other hand, the result is opposite from the case viewed from the ADSL terminal equipment (ATU-R) 4. In such a case, the interference noise transmitted by the office equipment (ISDN LT) 7 of the ISDN transmission system constitutes the NEXT noise, while the interference noise transmitted by the terminal equipment (ISDN NT1) 6 of the ISDN transmission system makes up the FEXT noise.
In overseas ISDN communication system which is full-duplexed, the up and down transmissions are performed at the same time. When viewed from the ADSL terminal equipment (ATU-R) 4, therefore, the NEXT noise generated by the terminal equipment (ISDN NT1) 6 of the ISDN transmission system nearer to the ADSL terminal equipment (ATU-R) 4 is controlling, i.e. has a larger effect.
For this reason, during the training period of the ADSL modem (not shown) installed at the ADSL terminal equipment 4, the characteristic of the NEXT noise components having a large effect is measured, and the number of transmission bits and the gain of each channel meeting the noise characteristic are determined by bit mapping. Further, in order to improve the transmission characteristics, the coefficients of the time domain equalizer (TEQ) for adaptive equalization in time domain and the frequency domain equalizer (FEQ) for adaptive equalization in frequency domain are converged and determined, so that a set of coefficient tables for NEXT noises are provided for each of TEQ and FEQ.
Although this measure eliminates the problem in the overseas digital communication systems, the half-duplex communication system TCM-ISDN employed in Japan as an existing ISDN communication system, in which the up and down data transmission are switched by time division like Ping-Pong poses a problem. Namely, in the case where the half-duplex transmission path and other transmission path are adjacently placed to each other as an aggregated line or the like, the NEXT noises and the FEXT noises from the half-duplex transmission path have an effect alternately on the communication terminals connected to the other transmission paths adjacent to the half-duplex transmission path.
In the Japanese ADSL system, therefore, a method is proposed in which the bit map is switched in accordance with the FEXT and NEXT sections of the TCM-ISDN interference noises (“G.lite: Proposal for draft of Annex of G.lite”, ITU-T, SG-15, Waikiki, Hawaii 29 Jun.–3 Jul. 1998, Temporary Document WH-047).
FIG. 13 shows an outline of a digital communication system using the digital communication equipment employing the method described in the above literature. In FIG. 13, numeral 11 designates a central office (CO) for controlling the TCM-ISDN communication and the ADSL communication, numeral 12 designates a TCM-ISDN transmission path for the TCM-ISDN communication, numeral 13 designates an ADSL transmission path for the ADSL communication, numeral 14 designates an ADSL terminal equipment (ATU-R; ADSL transceiver unit, remote terminal end) such as a communication modem for performing the ADSL communication with other ADSL communication terminal equipment (not shown) through the ADSL transmission path 13, numeral 15 designates an ADSL office equipment (ATU-C; ADSL transceiver unit, central office end) for controlling the ADSL communication within the central office 11, numeral 16 designates a TCM-ISDN terminal equipment (TCM-ISDN NT1) such as a communication modem for performing the TCM-ISDN communication with other TCM-ISDN terminal equipment (not shown) through the TCM-ISDN transmission path 12, numeral 17 designates a TCM-ISDN office equipment (TCM-ISDN LT) for controlling the TCM-ISDN communication in the central office 11, and numeral 18. designates a sync controller for synchronizing the communication between the TCM-ISDN office equipment (TCM-ISDN LT) 17 and the ADSL office equipment (ATU-C) 15. The sync controller 18 may alternatively be installed in the TCM-ISDN office equipment (TCM-ISDN LT) 17 or in the ADSL office equipment (ATU-C) 15.
As described above, the interference noise transmitted, through the TCM-ISDN transmission path 12 and the ADSL transmission path 13 adjacently placed to each other as an aggregated line, by the TCM-ISDN office equipment (TCM-ISDN LT) 17 providing a far half-duplex communication system when viewed from the ADSL terminal equipment (ATU-R) 14, as shown in FIG. 13, is called the “FEXT noise”. On the other hand, the interference noise transmitted, through the TCM-ISDN transmission path 12 and the ADSL transmission path 13 adjacently placed to each other as an aggregated line, by the TCM-ISDN terminal equipment (TCM-ISDN NT1) 16 constituting a near half-duplex communication system is called the “NEXT noise”.
When viewed from the ADSL office equipment (ATU-C) 15, on the other hand, the case is opposite to that viewed from the ADSL terminal equipment (ATU-R) 14, and the interference noise transmitted by the office equipment (ISDN LT) 17 of the ISDN transmission system constituting the near half-duplex communication system is the NEXT noise, while the interference noise transmitted by the terminal equipment (ISDN NT1) 16 of the ISDN transmission system making up a far half-duplex communication system constitutes the FEXT noise.
FIG. 14 shows a functional configuration of a transmission unit or a dedicated transmitter (hereinafter collectively referred to as the transmission system) such as a communication modem of the ADSL office equipment (ATU-C; ADSL transceiver unit, central office end) 15 of the digital communication system. On the other hand, FIG. 15 shows a functional configuration of a receiving unit or a dedicated receiver (hereinafter collectively referred to as the receiving system) such as a communication modem of the ADSL terminal equipment (ATU-R) 14 of the digital communication system.
In FIG. 14, numeral 41 designates a multiplex/sync controller, numerals 42 and 43 designate cyclic redundancy check (crc) units, numerals 44 and 45 designate scramble forward error correction units (Scram and FEC), numeral 46 designates an interleaver, numerals 47 and 48 designate rate converters, numeral 49 designates a tone ordering unit, numeral 50 a constellation encoder and gain scaling unit, numeral 51 designates an inverse discrete Fourier transform unit (IDFT), numeral 52 designates an input parallel/serial buffer, and numeral 53 designates an analog processing and D/A converter (DAC).
In FIG. 15, numeral 141 designates an analog processing and A/D converter (ADC), numeral 142 designates a time domain equalizer (TEQ), numeral 143 designates an input serial/parallel buffer, numeral 144 designates a discrete Fourier transform unit (DFT), numeral 145 designates a frequency domain equalizer (FEQ), numeral 146 designates a constellation encoder and gain scaling unit, numeral 147 designates a tone ordering unit, numerals 148 and 149 designate rate converters, numeral 150 designates a deinterleaver, numerals 151 and 152 designate descramble forward error correction units (FEC), numerals 153 and 154 designate cyclic redundancy check units (crc), and numeral 155 designate a multiplex/sync controller.
Now, the operation will be explained. To begin with, the operation of the transmission system of the ADSL office equipment (ATU-C) 15 will be explained. In FIG. 14, the transmission data are multiplexed by the multiplex/sync controller 41, and have an error detection code added thereto by the cyclic redundancy check units 42, 43, have the FEC code added thereto and subjected to the scramble processing by the scramble forward error correction units 44, 45, sometimes followed by the processing in the interleaver 46. After that, the rate is converted by the rate converters 47, 48, the tone ordering is executed by the tone ordering unit 49, the constellation data are produced by the constellation encoder and gain scaling unit 50, the inverse discrete Fourier transform is performed by the inverse discrete Fourier transform unit 51, the digital waveform is converted into an analog waveform through the D/A converter, and then the signal is passed through a low-pass filter.
The operation of the receiving system of the ADSL terminal equipment (ATU-R) 14 will now be explained. In FIG. 15, the analog processing A/D converter 141 applies the received signal through a low-pass filter, and converts the analog waveform into a digital waveform through the A/D converter, followed by the time domain adaptive equalization in the time domain equalizer (TEQ) 142.
Then, the data subjected to the time domain adaptive equalization are converted from serial to parallel data by the input serial/parallel buffer 143, subjected to discrete Fourier transform in the discrete Fourier transform unit (DFT) 144, and then subjected to frequency domain adaptive equalization by the frequency domain equalizer (FEQ) 145.
The constellation data are reproduced by the constellation encoder and gain scaling unit 146, converted into the serial data by the tone ordering unit 147, have the rate converted in the rate converters 148, 149, subjected to the descramble processing and FEC by the descramble and forward error correction unit 151, and in some cases, after being deinterleaved by the deinterleaver 150, subjected to FEC and descramble processing by the descramble and forward error correction unit 152. After the processing in the cyclic redundancy check unit 153, 154, the data are reproduced by the multiplex/sync controller 155.
In this process, the sync controller 18 of the central office (CO) 11 synchronizes the transmission timing between the TCM-ISDN office equipment (TCM-ISDN LT) 17 and the ADSL office equipment (ATU-C) 15. Thus, the ADSL terminal equipment (ATU-R) 14 can recognize the timing of generation of NEXT noise and FEXT noise.
Specifically, the ADSL terminal equipment (ATU-R) 14, by the synchronization between the TCM-ISDN communication and the ADSL communication, determines that the NEXT noise is generated in the received data or the signal received through the ADSL transmission path 13 during a predetermined time when the data are transmitted up the TCM-ISDN transmission path 12 at a known timing. On the other hand, during a predetermined time when the data are transmitted down the TCM-ISDN transmission path 12 at a known timing, the generation of the FEXT can be similarly recognized in the data received through the ADSL transmission path 13.
In the Japanese ADSL system, as shown in FIG. 16, the bit map A and the bit map B are assigned to the FEXT sections and the NEXT sections, respectively, and in the rate converters 47, 48 of FIG. 14, more bits are assigned to the FEXT section having a small noise, and less bits are assigned to the NEXT section having a large noise. As a result, the transmission rate can be improved as compared with the conventional case in which the bit distribution is determined only by the NEXT section.
FIG. 17 shows the manner in which the data received at the uniform rate (64 kbps in the calculation example below) are assigned to the bit map A and the bit map B at the time of transmission. First, the data sent in at the uniform rate are stored in the form of fixed bits in units of symbols. These data are converted into bits for the bit map A and the bit map B by the rate converter. An integer multiple is not involved, however, because the interval of the transmitted symbols is 246 μs for the ISDN period of 2.5 ms.
Thus, as shown in FIG. 18, with 34 periods (=345 symbols, 85 ms) as one unit (hyperframe), only the FEXT section in the hyperframe where the symbols are filled up is defined as a bit map A, and the other portions as a bit map B (in the drawing, SS and ISS indicate sync signals) . Whether each DMT symbol is associated with the bit map A or the bit map B is determined from the following equations. (In the equations below, the DMT symbol No. is assumed to be Ndmt).    Transmission from ATU-C to ATU-Ri S=272×Ndmt mod 2760
if {(S+271<a) or (S>a+b)} then [bit map A symbol]
if {(S+271>=a) and (S<=a+b)} then [bit map B symbol]
where a=1243, and b=1461.
    Transmission from ATU-R to ATU-CS=272×Ndmt mod 2760
if {(S>a) and (S+271<a+b)} then [bit map A symbol]
if {(S<=a) or (S+271>=a+b)} then [bit map B symbol]
where a=1315, and b=1293.
An example of calculation for determining the bit assignment for the single bit map using only the bit map A is shown below.
                                                        .              Number                        ⁢                                                  ⁢            of            ⁢                                                  ⁢            bits            ⁢                                                  ⁢            of            ⁢                                                  ⁢            1                                                            DMT            ⁢                                                  ⁢            symbol            ⁢                                                  ⁢                          (              before                                                                                      rate              ⁢                                                          ⁢              conversion                        )                                ⁢                                        =                        ⁢                                          (                                  transmission                  ⁢                                                                          ⁢                  rate                                )                            ×                              (                transmission                                                                                                                  ⁢              time              )                        /                          (                              total                ⁢                                                                  ⁢                number                ⁢                                                                  ⁢                of                ⁢                                                                  ⁢                symbols                                                                                                  ⁢                          (                              except                ⁢                                                                  ⁢                for                ⁢                                                                  ⁢                ISS                ⁢                                                                  ⁢                                  (                                      inverse                    ⁢                                                                                  ⁢                    sync                                                                                                                                                                                          ⁢                  symbol                  )                                ⁢                                                                  ⁢                and                ⁢                                                                  ⁢                SS                ⁢                                                                  ⁢                                  (                                      sync                    ⁢                                                                                  ⁢                    symbol                                    )                                            )                        )                                                            =                        ⁢                          64              ⁢                                                          ⁢              kbps              ×              85              ⁢                                                          ⁢                              ms                /                340                                                                                      =                        ⁢                          16              ⁢                                                          ⁢              bits                                                                                                  .              Number                        ⁢                                                  ⁢            of            ⁢                                                  ⁢            bits                                                            of            ⁢                                                  ⁢            bit            ⁢                                                  ⁢            map            ⁢                                                  ⁢            A                                ⁢                                        =                        ⁢                                          (                                  transmission                  ⁢                                                                          ⁢                  rate                                )                            ×                                                (                                      transmission                    ⁢                                                                                  ⁢                    time                                    )                                /                                                                                                  ⁢                          (                              total                ⁢                                                                  ⁢                number                ⁢                                                                  ⁢                of                ⁢                                                                  ⁢                symbols                ⁢                                                                  ⁢                of                ⁢                                                                  ⁢                bit                ⁢                                                                  ⁢                map                ⁢                                                                  ⁢                A                                                                                                  ⁢                          (                              except                ⁢                                                                  ⁢                for                ⁢                                                                  ⁢                ISS                ⁢                                                                  ⁢                                  (                                      inverse                    ⁢                                                                                  ⁢                    sync                    ⁢                                                                                  ⁢                    symbol                                    )                                                                                                                                  ⁢                              and                ⁢                                                                  ⁢                SS                ⁢                                                                  ⁢                                  (                                      side                    ⁢                                                                                  ⁢                    A                    ⁢                                                                                  ⁢                    sync                    ⁢                                                                                  ⁢                    symbol                                    )                                            )                        )                                                            =                        ⁢                          64              ⁢                                                          ⁢              kbps              ×              85              ⁢                                                          ⁢                              ms                /                126                                                                                      =                        ⁢            43.175                              
Thus, the bit map A is assumed to be equal to 44 bits. Also, because of a single bit map (only the bit map A is used), the bit map B is set to zero.
In this bit distribution, transmission is started only after data are stored to some degree at the uniform rate. Therefore, a delay time is generated at the time of transmission of each symbol. This delay time differs depending upon the symbol number (place of each symbol). As a result of determining the delay time for all the symbols in the example of FIG. 18, the symbol No. 145 is found to have a maximum delay time. An example of calculation of the delay time using the bit assignment determined by the foregoing calculation is explained below. FIG. 19 shows a transmission delay.
                                          .            Transmission                    ⁢                                          ⁢          delay                                              time          ⁢                                          ⁢                      (                          worst              ⁢                                                          ⁢              value              ⁢                                                          ⁢              is                                                                                for            ⁢                                                  ⁢            symbol            ⁢                                                  ⁢                          No              .                                                          ⁢              145                                )                      ⁢                              =                    ⁢                      (                          time              ⁢                                                          ⁢              required              ⁢                                                          ⁢              for              ⁢                                                          ⁢              storing              ⁢                                                          ⁢              total              ⁢                                                          ⁢              number                                                                                            ⁢                          of              ⁢                                                          ⁢              transmitted              ⁢                                                          ⁢              bits                        )                    -                      (                                          symbol                ⁢                                                                  ⁢                No                ⁢                                  .                                            ⁢                                                          +                                                                                            ⁢            1            )                    ×                      (                          one              ⁢                                                          ⁢              symbol              ⁢                                                          ⁢              time                        )                                                        =                    ⁢                                    (                              total                ⁢                                                                  ⁢                number                ⁢                                                                  ⁢                of                ⁢                                                                  ⁢                transmitted                ⁢                                                                  ⁢                bits                            )                        /                                                                  ⁢                                    (                              transmission                ⁢                                                                  ⁢                rate                            )                        -                                          (                                                      symbol                    ⁢                                                                                  ⁢                    No                    ⁢                                          .                                                        +                  1                                )                            ×                                                                              ⁢                      (                          one              ⁢                                                          ⁢              symbol              ⁢                                                          ⁢              time                        )                                                        =                    ⁢                                    (                              number                ⁢                                                                  ⁢                of                ⁢                                                                  ⁢                bit                ⁢                                                                  ⁢                map                ⁢                                                                  ⁢                A                            )                        ×                          (                              number                ⁢                                                                  ⁢                of                                                                                                                          ⁢                              bits                ⁢                                                                  ⁢                of                ⁢                                                                  ⁢                bit                ⁢                                                                  ⁢                map                ⁢                                                                  ⁢                A                            )                        /                          (                              transmission                ⁢                                                                  ⁢                rate                            )                                -                                                        ⁢                                    (                                                symbol                  ⁢                                                                          ⁢                  No                  ⁢                                      .                                                  +                1                            )                        ×                          (                              1                ⁢                                                                  ⁢                symbol                ⁢                                                                  ⁢                time                            )                                                                    =                    ⁢                                    58              ×                              44                /                64                            ⁢                                                          ⁢              kbps                        -                          146              ×                                                                              ⁢                      (                          0.25              ⁢                                                          ⁢              ms              ×                              272                /                276                                      )                                                        =                    ⁢                      3.9040            ⁢                                                  ⁢            ms                              
In order not to interrupt the data after rate conversion due to the delay at the transmitting end, the corresponding amount is offset using a buffer or the like. The sum 4.1504 ms of this offset (3.9040 ms) and one symbol time (0.24637 ms) constituting the processing delay of the inverse discrete Fourier transform unit (IDFT) in the transmission unit is the transmission delay.
At the receiving end, on the other hand, the data sent in are converted into a uniform rate. In this process, it may happen that the data which otherwise should have arrived at uniform rate may fail to do so due to the change in bit distribution at the time of transmission at the transmitting end (see FIG. 20). This delay time at the receiving end is maximum for symbol No. 30 in the case shown in FIG. 18.
                                          .            Receiving                    ⁢                                          ⁢          delay          ⁢                                          ⁢          time                                              (                      worst            ⁢                                                  ⁢            value            ⁢                                                  ⁢            is            ⁢                                                  ⁢            for                                                                    symbol            ⁢                                                  ⁢                          No              .                                                          ⁢              30                                )                      ⁢                              =                    ⁢                                                    (                                                      symbol                    ⁢                                                                                  ⁢                    No                    ⁢                                          .                                                        +                  1                                )                            ×                              (                                  one                  ⁢                                                                          ⁢                  symbol                  ⁢                                                                          ⁢                  time                                )                                      -                                                                  ⁢                                    (                              total                ⁢                                                                  ⁢                number                ⁢                                                                  ⁢                of                ⁢                                                                  ⁢                transmitted                ⁢                                                                  ⁢                bits                            )                        /                                                                  ⁢                      (                          transmission              ⁢                                                          ⁢              rate                        )                                                        =                    ⁢                                                    (                                                      symbol                    ⁢                                                                                  ⁢                    No                    ⁢                                          .                                                        +                  1                                )                            ×                              (                                  one                  ⁢                                                                          ⁢                  symbol                  ⁢                                                                          ⁢                  time                                )                                      -                                                                  ⁢                                    (                              number                ⁢                                                                  ⁢                of                ⁢                                                                  ⁢                bit                ⁢                                                                  ⁢                map                ⁢                                                                  ⁢                A                            )                        ×                          (                              number                ⁢                                                                  ⁢                of                                                                                                          ⁢                          bits              ⁢                                                          ⁢              of              ⁢                                                          ⁢              bit              ⁢                                                          ⁢              map              ⁢                                                          ⁢              A                        )                    /                      (                          transmission              ⁢                                                          ⁢              rate                        )                                                        =                    ⁢                                    31              ×              0.25              ⁢                                                          ⁢              ms              ×                              272                /                276                                      -                                                                  ⁢                      11            ×                          44              /              64                        ⁢                                                  ⁢            kbps                                                        =                    ⁢                      0.07518            ⁢                                                  ⁢            ms                              
In order not to interrupt the data after rate conversion due to this delay at the receiving end, a corresponding amount is offset using a buffer or the like. As a result, the sum 0.32155 ms of the offset (0.07518 ms) and one symbol time (0.24637 ms) constituting the processing delay in the discrete Fourier transform unit (DFT) is determined as the receiving delay.
Thus, for the transmission rate of 64 kbps, the sum 4.4719 ms of the transmission delay time (4.1504 ms) and the receiving delay time (0.32155 ms) makes up the maximum delay time in the transmission and receiving units.
The following is an example of calculation for determining the bit assignment for the dual bit map where both the bit map A and the bit map B are used.
          ⁢                                                        .              Number                        ⁢                                                  ⁢            of            ⁢                                                  ⁢            bits            ⁢                                                  ⁢            of            ⁢                                                  ⁢            1                                                            DMT            ⁢                                                  ⁢            symbol            ⁢                                                  ⁢                          (              before                                                                                      rate              ⁢                                                          ⁢              conversion                        )                                ⁢                                        =                        ⁢                                          (                                  transmission                  ⁢                                                                          ⁢                  rate                                )                            ×                              (                transmission                ⁢                                                                                                                                                                    ⁢              time              )                        /                          (                              total                ⁢                                                                  ⁢                number                ⁢                                                                  ⁢                of                ⁢                                                                  ⁢                symbols                                                                                                  ⁢                          (                              except                ⁢                                                                  ⁢                for                ⁢                                                                  ⁢                ISS                ⁢                                                                  ⁢                                  (                                      inverse                    ⁢                                                                                  ⁢                    sync                                    ⁢                                                                                                                                                                                                                                ⁢                  symbol                  )                                ⁢                                                                  ⁢                and                ⁢                                                                  ⁢                SS                ⁢                                                                  ⁢                                  (                                      sync                    ⁢                                                                                  ⁢                    symbol                                    )                                            )                        )                                                            =                        ⁢                          64              ⁢                                                          ⁢              kpbs              ×              85              ⁢                                                          ⁢                              ms                /                340                                                                                      =                        ⁢                          16              ⁢                                                          ⁢              bits                                              This calculation example assumes that the number of bits of the bit map B is 3.
                                          .            Number                    ⁢                                          ⁢          of          ⁢                                          ⁢          bits                                              of          ⁢                                          ⁢          bit          ⁢                                          ⁢          map          ⁢                                          ⁢          A                      ⁢                              =                    ⁢                      (                                                            (                                      transmission                    ⁢                                                                                  ⁢                    rate                                    )                                ×                                  (                                      transmission                    ⁢                                                                                  ⁢                    time                                    )                                            -                                                                              ⁢                      (                          number              ⁢                                                          ⁢              of              ⁢                                                          ⁢              bits              ⁢                                                          ⁢              per              ⁢                                                          ⁢              symbol              ⁢                                                          ⁢              of              ⁢                                                          ⁢              bit              ⁢                                                          ⁢              map                                                                                            ⁢            B            )                    ×                      (                          number              ⁢                                                          ⁢              of              ⁢                                                          ⁢              symbols              ⁢                                                          ⁢              of              ⁢                                                          ⁢              bit              ⁢                                                          ⁢              map              ⁢                                                          ⁢              B                                                                              ⁢                      (                          except              ⁢                                                          ⁢              for              ⁢                                                          ⁢              ISS              ⁢                                                          ⁢                              (                                  inverse                  ⁢                                                                          ⁢                  sync                  ⁢                                                                          ⁢                  symbol                                )                                                                                                                          ⁢                              and                ⁢                                                                  ⁢                SS                ⁢                                                                  ⁢                                  (                                      side                    ⁢                                                                                  ⁢                    A                    ⁢                                                                                  ⁢                    sync                    ⁢                                                                                  ⁢                    symbol                                    )                                            )                        )                    /                      (            number                                                                  ⁢                      of            ⁢                                                  ⁢            symbols            ⁢                                                  ⁢            of            ⁢                                                  ⁢            bit            ⁢                                                  ⁢            map            ⁢                                                  ⁢            A            ⁢                                                  ⁢                          (                              except                ⁢                                                                  ⁢                for                                                                                            ⁢                      ISS            ⁢                                                  ⁢                          (                              inverse                ⁢                                                                  ⁢                sync                ⁢                                                                  ⁢                symbol                            )                        ⁢                                                  ⁢            and            ⁢                                                  ⁢            SS                    ⁢                                                                                                      ⁢                          (                              side                ⁢                                                                  ⁢                A                ⁢                                                                  ⁢                sync                ⁢                                                                  ⁢                symbol                            )                        )                    )                                              =                    ⁢                                    (                                                64                  ⁢                                                                          ⁢                  kbps                  ×                  85                  ⁢                                                                          ⁢                  ms                                -                                  3                  ×                  214                                            )                        /            126                                                        =                    ⁢                      38.079            ⁢                                                  ⁢            bits                              Thus, the bit map A has 39 bits.
In this bit distribution, the data at the uniform rate are transmitted only after being stored to some degree, and therefore a delay time occurs when each symbol is transmitted. This delay time differs depending upon the symbol No. (place of each symbol). In the case of FIG. 18 (39 bits distributed to bit map A and 3 bits to bit map B), assume that the delay time is determined for all the symbols. The symbol associated with the maximum delay time is symbol No. 145. An example calculation of the delay time using the bit distribution determined in the aforementioned calculation example is shown below. FIG. 21 shows a transmission delay.
                                          .            Transmission                    ⁢                                          ⁢          delay                                              time          ⁢                                          ⁢                      (                          worst              ⁢                                                          ⁢              value              ⁢                                                          ⁢              is                                                                                for            ⁢                                                  ⁢            symbol            ⁢                                                  ⁢                          No              .                                                          ⁢              145                                )                      ⁢                              =                    ⁢                      (                          time              ⁢                                                          ⁢              required              ⁢                                                          ⁢              for              ⁢                                                          ⁢              storing              ⁢                                                          ⁢              total              ⁢                                                          ⁢              number                                                                                            ⁢                          of              ⁢                                                          ⁢              transmitted              ⁢                                                          ⁢              bits                        )                    -                                    (                                                symbol                  ⁢                                                                          ⁢                  No                  ⁢                                      .                                                  +                1                            )                        ×                                                                  ⁢                      (                          one              ⁢                                                          ⁢              symbol              ⁢                                                          ⁢              time                        )                                                        =                    ⁢                                    (                              total                ⁢                                                                  ⁢                number                ⁢                                                                  ⁢                of                ⁢                                                                  ⁢                transmitted                ⁢                                                                  ⁢                bits                            )                        /                                                                  ⁢                                    (                              transmission                ⁢                                                                  ⁢                rate                            )                        -                                          (                                                      symbol                    ⁢                                                                                  ⁢                    No                    ⁢                                          .                                                        +                  1                                )                            ×                                                                              ⁢                      (                          one              ⁢                                                          ⁢              symbol              ⁢                                                          ⁢              time                        )                                                        =                    ⁢                      (                                          (                                  number                  ⁢                                                                          ⁢                  of                  ⁢                                                                          ⁢                  bit                  ⁢                                                                          ⁢                  map                  ⁢                                                                          ⁢                  A                                )                            ×                              (                                  number                  ⁢                                                                          ⁢                  of                                                                                                                          ⁢                          bits              ⁢                                                          ⁢              of              ⁢                                                          ⁢              bit              ⁢                                                          ⁢              map              ⁢                                                          ⁢              A                        )                    +                      (                          number              ⁢                                                          ⁢              of              ⁢                                                          ⁢              bit                                                                                            ⁢                          map              ⁢                                                          ⁢              B                        )                    ×                      (                          number              ⁢                                                          ⁢              of              ⁢                                                          ⁢              bits              ⁢                                                          ⁢              of              ⁢                                                          ⁢              bit              ⁢                                                          ⁢              map                                                                                                                              ⁢                B                )                            )                        /                          (                              transmission                ⁢                                                                  ⁢                rate                            )                                -                      (            symbol                                                                                ⁢                                          No                ⁢                                  .                                            +              1                        )                    ×                      (                          one              ⁢                                                          ⁢              symbol              ⁢                                                          ⁢              time                        )                                                        =                    ⁢                                                                      (                                                            58                      ×                      39                                        +                                          86                      ×                      3                                                        )                                /                64                            ⁢                                                          ⁢              kbps                        -                          146              ×                                                                              ⁢                      (                          0.25              ⁢                                                          ⁢              ms              ×                              272                /                276                                      )                                                        =                    ⁢                      3.4040            ⁢                                                  ⁢            ms                              
In order not to interrupt the data after rate conversion due to this delay at the transmitting end, a corresponding amount is offset using a buffer or the like. As a result, the sum 3.6504 ms of the offset (3.4040 ms) and one symbol time (0.24637 ms) making up the processing delay of the inverse discrete Fourier transform unit (IDFT) constitutes the transmission delay.
At the receiving end, on the other hand, the data sent in are converted into a uniform rate. In this process, it may happen that the data which otherwise should have arrived at uniform rate fail to do so due to the change in bit distribution at the time of being transmitted at the transmitting end (see FIG. 22). This delay time at the receiving end is maximum for symbol No. 30 in the case shown in FIG. 18.
                                          .            Receiving                    ⁢                                          ⁢          delay          ⁢                                          ⁢          time                                              (                      worst            ⁢                                                  ⁢            value            ⁢                                                  ⁢            is            ⁢                                                  ⁢            for                                                                    symbol            ⁢                                                  ⁢                          No              .                                                          ⁢              30                                )                      ⁢                              =                    ⁢                                                    (                                                      symbol                    ⁢                                                                                  ⁢                    No                    ⁢                                          .                                                        +                  1                                )                            ×                              (                                  one                  ⁢                                                                          ⁢                  symbol                  ⁢                                                                          ⁢                  time                                )                                      -                                                                  ⁢                                    (                              total                ⁢                                                                  ⁢                number                ⁢                                                                  ⁢                of                ⁢                                                                  ⁢                transmitted                ⁢                                                                  ⁢                bits                            )                        /                                                                  ⁢                      (                          transmission              ⁢                                                          ⁢              rate                        )                                                        =                    ⁢                                                    (                                                      symbol                    ⁢                                                                                  ⁢                    No                    ⁢                                          .                                                        +                  1                                )                            ×                              (                                  one                  ⁢                                                                          ⁢                  symbol                  ⁢                                                                          ⁢                  time                                )                                      -                                                                  ⁢                      (                                          (                                  number                  ⁢                                                                          ⁢                  of                  ⁢                                                                          ⁢                  bit                  ⁢                                                                          ⁢                  map                  ⁢                                                                          ⁢                  A                                )                            ×                              (                                  number                  ⁢                                                                          ⁢                  of                                                                                                                          ⁢                          of              ⁢                                                                                ⁢                                                                              ⁢              bits              ⁢                                                          ⁢              of              ⁢                                                          ⁢              bit              ⁢                                                          ⁢              map              ⁢                                                          ⁢              A                        )                    +                      (                          number              ⁢                                                          ⁢              of                                                                                            ⁢                          bit              ⁢                                                          ⁢              map              ⁢                                                          ⁢              B                        )                    ×                      (                          number              ⁢                                                          ⁢              of              ⁢                                                          ⁢              bits              ⁢                                                          ⁢              of              ⁢                                                          ⁢              bit                                                                                                            ⁢                              map                ⁢                                                                  ⁢                B                            )                        )                    /                      (                          transmission              ⁢                                                          ⁢              rate                        )                                                        =                    ⁢                                    31              ×              0.25              ⁢                                                          ⁢              ms              ×                              272                /                276                                      -                                                                  ⁢                                                    (                                                      11                    ×                    39                                    +                                      20                    ×                    3                                                  )                            /              64                        ⁢                                                  ⁢            kbps                                                        =                    ⁢                                    -              0.0029438                        ⁢                                                  ⁢            ms                              
This delay at the receiving end is on minus side at worst, and therefore can be offset by the aforementioned amount in advance. The sum 0.24343 ms of the offset (−0.0029438 ms) and one symbol time (0.24637 ms) making up the processing delay of the discrete Fourier transform unit (DFT) in the receiving unit is determined as the receiving delay.
Thus, for the transmission rate of 64 kbps, the maximum delay time in the transmission and receiving units is 3.8938 ms which is the sum of the transmission delay time of 3.6504 ms and the receiving delay time of 0.24343 ms.
This system poses the problem of an excessively large delay.
Accordingly, an object of the present invention is to provide a communication system and a communication method capable of suppressing the delay within a predetermined period (for example one ISDN period (2.5 ms)).